{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook has been prepared based on the homework given in [berkeleydeeprl course](https://github.com/berkeleydeeprlcourse/homework/blob/0015ad14cf155d59fede725f2d783f4683cc8215/sp17_hw/hw2/HW2.ipynb) and https://github.com/dennybritz/reinforcement-learning.\n",
    "This reviews the two classic methods for solving Markov Decision Processes (MDPs) with finite state and action spaces. We have value iteration (VI) and policy iteration (PI) for a finite MDP, both of which find the optimal policy in a finite number of iterations.\n",
    "\n",
    "The experiments here use the [Frozen Lake environment](https://gym.openai.com/envs/FrozenLake-v0), a simple gridworld MDP that is taken from gym. In this MDP, the agent must navigate from the start state to the goal state on a 4x4 grid, with stochastic transitions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# © Ozan Arkan Can, 2018.\n",
    "ENV[\"GYM_ENVS\"]=\"atari:classic_control:box2d\"\n",
    "using Gym, Random, Printf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = GymEnv(\"FrozenLake-v0\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Winter is here. You and your friends were tossing around a frisbee at the\n",
      "    park when you made a wild throw that left the frisbee out in the middle of\n",
      "    the lake. The water is mostly frozen, but there are a few holes where the\n",
      "    ice has melted. If you step into one of those holes, you'll fall into the\n",
      "    freezing water. At this time, there's an international frisbee shortage, so\n",
      "    it's absolutely imperative that you navigate across the lake and retrieve\n",
      "    the disc. However, the ice is slippery, so you won't always move in the\n",
      "    direction you intend.\n",
      "    The surface is described using a grid like the following\n",
      "\n",
      "        SFFF\n",
      "        FHFH\n",
      "        FFFH\n",
      "        HFFG\n",
      "\n",
      "    S : starting point, safe\n",
      "    F : frozen surface, safe\n",
      "    H : hole, fall to your doom\n",
      "    G : goal, where the frisbee is located\n",
      "\n",
      "    The episode ends when you reach the goal or fall in a hole.\n",
      "    You receive a reward of 1 if you reach the goal, and zero otherwise.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "println(env.gymenv[:unwrapped][:__doc__])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[41mS\u001b[0mFFF\n",
      "FHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Down)\n",
      "SFFF\n",
      "\u001b[41mF\u001b[0mHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Left)\n",
      "\u001b[41mS\u001b[0mFFF\n",
      "FHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Up)\n",
      "S\u001b[41mF\u001b[0mFF\n",
      "FHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Down)\n",
      "SF\u001b[41mF\u001b[0mF\n",
      "FHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Down)\n",
      "S\u001b[41mF\u001b[0mFF\n",
      "FHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Up)\n",
      "SF\u001b[41mF\u001b[0mF\n",
      "FHFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Down)\n",
      "SFFF\n",
      "FH\u001b[41mF\u001b[0mH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Left)\n",
      "SFFF\n",
      "FHFH\n",
      "FF\u001b[41mF\u001b[0mH\n",
      "HFFG\n",
      "\n",
      "  (Up)\n",
      "SFFF\n",
      "FH\u001b[41mF\u001b[0mH\n",
      "FFFH\n",
      "HFFG\n",
      "\n",
      "  (Up)\n",
      "SFFF\n",
      "F\u001b[41mH\u001b[0mFH\n",
      "FFFH\n",
      "HFFG\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Random.seed!(1); seed!(env, 1);\n",
    "irender(env)=println(render(env; mode=\"ansi\"))\n",
    "reset!(env)\n",
    "irender(env)\n",
    "for t=1:100\n",
    "    a = sample(env.action_space)\n",
    "    ob, rew, done, _ = step!(env, a)\n",
    "    irender(env)\n",
    "    if done\n",
    "        break\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the episode above, the agent falls into a hole after two time steps. Also note the stochasticity on the second step, the Right action is selected, but the agent moves down.\n",
    "\n",
    "We extract the relevant information from the gym env into the MDP struct below. The env object won't be used any further, we'll just use the mdp object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mdp.P is a two-level dict where the first key is the state and the second key is the action.\n",
      "The 2D grid cells are associated with indices [1, 2, ..., 16] from left to right and top to down, as in\n",
      "[1 2 3 4\n",
      " 5 6 7 8\n",
      " 9 10 11 12\n",
      " 13 14 15 16]\n",
      "mdp.P[state][action] is a list of tuples (probability, nextstate, reward).\n",
      "\n",
      "For example, state 1 is the initial state, and the transition information for s=1, a=1 is \n",
      "P[1][1] =Any[(0.1, 1, 0.0), (0.8, 1, 0.0), (0.1, 5, 0.0)]\n",
      "\n",
      "As another example, state 6 corresponds to a hole in the ice, which transitions to itself with probability 1 and reward 0.\n",
      "P[6][1] =Any[(1.0, 6, 0)]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "mutable struct MDP\n",
    "    P # state transition and reward probabilities, explained below\n",
    "    nS # number of states\n",
    "    nA # number of actions\n",
    "    desc # 2D array specifying what each grid cell means (used for plotting)\n",
    "end\n",
    "\n",
    "#We will modify the original transition matrix whicch allows more stable policies.\n",
    "#https://github.com/berkeleydeeprlcourse/homework/blob/60b3ef08c2dca3961efb63b32683bb588571f226/sp17_hw/hw2/frozen_lake.py#L89\n",
    "\n",
    "function inc(row, col, a)\n",
    "    if a==0 # left\n",
    "        col = max(col-1,0)\n",
    "    elseif a==1 # down\n",
    "        row = min(row+1,3)\n",
    "    elseif a==2 # right\n",
    "        col = min(col+1,3)\n",
    "    else # up\n",
    "        row = max(row-1,0)\n",
    "    end\n",
    "    return (row, col)\n",
    "end\n",
    "\n",
    "P = Dict(s => Dict(a => [] for a=1:4) for s=1:16)\n",
    "desc = map(x->convert(Array, x), env.gymenv[:unwrapped][:desc])\n",
    "for row=0:3\n",
    "    for col=0:3\n",
    "        s = row * 4 + col + 1\n",
    "        for a=1:4\n",
    "            li = P[s][a]\n",
    "            letter = desc[row+1][col+1]\n",
    "            if occursin(letter, \"GH\")\n",
    "                push!(li, (1.0, s, 0))\n",
    "            else            \n",
    "                for b in [(a+2)%4+1, a, a%4+1]\n",
    "                    newrow, newcol = inc(row, col, b-1)\n",
    "                    newstate = newrow * 4 + newcol + 1\n",
    "                    newletter = desc[newrow+1][newcol+1]\n",
    "                    reward = float(newletter == \"G\")\n",
    "                    push!(li, (b==a ? 0.8 : 0.1, newstate, reward))\n",
    "                end\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "end\n",
    "\n",
    "mdp = MDP(P, env.gymenv[:unwrapped][:nS], env.gymenv[:unwrapped][:nA],desc);\n",
    "println(\"mdp.P is a two-level dict where the first key is the state and the second key is the action.\")\n",
    "println(\"The 2D grid cells are associated with indices [1, 2, ..., 16] from left to right and top to down, as in\")\n",
    "println(\"[1 2 3 4\\n 5 6 7 8\\n 9 10 11 12\\n 13 14 15 16]\")\n",
    "println(\"mdp.P[state][action] is a list of tuples (probability, nextstate, reward).\\n\")\n",
    "println(\"For example, state 1 is the initial state, and the transition information for s=1, a=1 is \\nP[1][1] =\", mdp.P[1][1], \"\\n\")\n",
    "println(\"As another example, state 6 corresponds to a hole in the ice, which transitions to itself with probability 1 and reward 0.\")\n",
    "println(\"P[6][1] =\", mdp.P[6][1], '\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Value Iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we have the value iteration, which has the following pseudocode:\n",
    "\n",
    "---\n",
    "Initialize $V^{(0)}(s)=0$, for all $s$\n",
    "\n",
    "For $i=0, 1, 2, \\dots$\n",
    "- $V^{(i+1)}(s) = \\max_a \\sum_{s'} P(s,a,s') [ R(s,a,s') + \\gamma V^{(i)}(s')]$, for all $s$\n",
    "\n",
    "---\n",
    "\n",
    "We additionally define the sequence of greedy policies $\\pi^{(0)}, \\pi^{(1)}, \\dots, \\pi^{(n-1)}$, where\n",
    "$$\\pi^{(i)}(s) = \\arg \\max_a \\sum_{s'} P(s,a,s') [ R(s,a,s') + \\gamma V^{(i)}(s')]$$\n",
    "\n",
    "The code returns two lists: $[V^{(0)}, V^{(1)}, \\dots, V^{(n)}]$ and $[\\pi^{(0)}, \\pi^{(1)}, \\dots, \\pi^{(n-1)}]$\n",
    "\n",
    "We choose the lower-index action to break ties in $\\arg \\max_a$. This is done automatically by findmax. This will only affect the \"# chg actions\" printout below--it won't affect the values computed.\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "Warning: We make a copy of your value function each iteration and use that copy for the update--instead of updating the value function in place. \n",
    "Updating in-place is also a valid algorithm, sometimes called Gauss-Seidel value iteration or asynchronous value iteration, but it will cause you to get different results than presented here.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration | max|V-Vprev| | # chg actions | V[1]\n",
      "----------+--------------+---------------+---------\n",
      "   1      | 0.80000      |  N/A          | 0.000\n",
      "   2      | 0.60800      |    2          | 0.000\n",
      "   3      | 0.51984      |    2          | 0.000\n",
      "   4      | 0.39508      |    2          | 0.000\n",
      "   5      | 0.30026      |    1          | 0.000\n",
      "   6      | 0.25355      |    0          | 0.254\n",
      "   7      | 0.10478      |    0          | 0.345\n",
      "   8      | 0.09657      |    0          | 0.442\n",
      "   9      | 0.03656      |    0          | 0.478\n",
      "  10      | 0.02772      |    0          | 0.506\n",
      "  11      | 0.01111      |    0          | 0.517\n",
      "  12      | 0.00735      |    0          | 0.524\n",
      "  13      | 0.00310      |    0          | 0.527\n",
      "  14      | 0.00190      |    0          | 0.529\n",
      "  15      | 0.00083      |    0          | 0.530\n",
      "  16      | 0.00049      |    0          | 0.531\n",
      "  17      | 0.00022      |    0          | 0.531\n",
      "  18      | 0.00013      |    0          | 0.531\n",
      "  19      | 0.00006      |    0          | 0.531\n",
      "  20      | 0.00003      |    0          | 0.531\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Inputs:\n",
    "        mdp: MDP\n",
    "        gamma: discount factor\n",
    "        nIt: number of iterations, corresponding to n above\n",
    "    Outputs:\n",
    "        (value_functions, policies)\n",
    "\"\"\"\n",
    "function value_iteration(mdp, gamma, nIt)\n",
    "    \"\"\"\n",
    "        Helper function to calculate the value for all action in a given state.\n",
    "        \n",
    "        Args:\n",
    "            state: The state to consider (int)\n",
    "            V: The value to use as an estimator, Vector of length mdp.nS\n",
    "        \n",
    "        Returns:\n",
    "            A vector of length mdp.nA containing the expected value of each action.\n",
    "    \"\"\"\n",
    "    function one_step_lookahead(state, V)\n",
    "        A = zeros(mdp.nA)\n",
    "        for a=1:mdp.nA\n",
    "            for (prob, next_state, reward) in mdp.P[state][a]\n",
    "                A[a] += prob * (reward + γ * V[next_state])\n",
    "            end\n",
    "        end\n",
    "        return A\n",
    "    end\n",
    "    \n",
    "    println(\"Iteration | max|V-Vprev| | # chg actions | V[1]\")\n",
    "    println(\"----------+--------------+---------------+---------\")\n",
    "    \n",
    "    Vs = [zeros(mdp.nS)] # list of value functions contains the initial value function V^{(0)}, which is zero\n",
    "    πs = []\n",
    "    for it=1:nIt\n",
    "        old_π = length(πs) > 0 ? πs[end] : nothing # \\pi^{(it)} = Greedy[V^{(it-1)}]. Just used for printout\n",
    "        Vprev = Vs[end] # V^{(it)}\n",
    "        # V: bellman backup on Vprev\n",
    "        #     corresponding to the math above: V^{(it+1)} = T[V^{(it)}]\n",
    "        #     array of floats\n",
    "        V = zeros(mdp.nS)\n",
    "        for s=1:mdp.nS\n",
    "            # Do a one-step lookahead to find the best action\n",
    "            A = one_step_lookahead(s, Vprev)\n",
    "            best_action_value = maximum(A)\n",
    "            # Update the value function\n",
    "            V[s] = best_action_value \n",
    "        end\n",
    "        \n",
    "        # π: greedy policy for Vprev, \n",
    "        #     corresponding to the math above: \\pi^{(it)} = Greedy[V^{(it)}]\n",
    "        #     array of ints\n",
    "        π = zeros(Int, mdp.nS)\n",
    "        for s=1:mdp.nS\n",
    "            # One step lookahead to find the best action for this state\n",
    "            A = one_step_lookahead(s, V)\n",
    "            #there might me more than one action with max value\n",
    "            #chose the first one\n",
    "            best_action = findmax(A)[2]\n",
    "            # Always take the best action\n",
    "            π[s] = best_action\n",
    "        end\n",
    "        \n",
    "        max_diff = maximum(abs.(V - Vprev))\n",
    "        nChgActions= old_π == nothing ? \"N/A\" : sum((π .!= old_π))\n",
    "        println(@sprintf(\"%4i      | %6.5f      | %4s          | %5.3f\", it, max_diff, nChgActions, V[1]))\n",
    "        push!(Vs, V)\n",
    "        push!(πs, π)\n",
    "    end\n",
    "    return Vs, πs\n",
    "end\n",
    "\n",
    "γ=0.95 # we'll be using this same value in subsequent implementations\n",
    "Vs_VI, πs_VI = value_iteration(mdp, γ, 20);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Policy (1=left, 2=down, 3=right, 4=up)\n",
      "(reshape(πs_VI[end], 4, 4))' = [2 3 2 1; 2 1 2 1; 3 2 2 1; 1 3 3 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Int64,Array{Int64,2}}:\n",
       " 2  3  2  1\n",
       " 2  1  2  1\n",
       " 3  2  2  1\n",
       " 1  3  3  1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Policy (1=left, 2=down, 3=right, 4=up)\")\n",
    "@show reshape(πs_VI[end], 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Value Function\n",
      "(reshape(Vs_VI[20], 4, 4))' = [0.5311209619007249 0.47061252674792037 0.5604169808918706 0.47061252674792037; 0.5736690281755391 0.0 0.6197477875693487 0.0; 0.6831381075836228 0.8271689274889868 0.8154595058193695 0.0; 0.0 0.901059977020324 0.9695783717534407 0.0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Float64,Array{Float64,2}}:\n",
       " 0.531121  0.470613  0.560417  0.470613\n",
       " 0.573669  0.0       0.619748  0.0\n",
       " 0.683138  0.827169  0.81546   0.0\n",
       " 0.0       0.90106   0.969578  0.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Value Function\")\n",
    "@show reshape(Vs_VI[20], 4, 4)'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Policy Iteration\n",
    "\n",
    "Next we will implement the policy iteration (PI), which has the following pseudocode:\n",
    "\n",
    "---\n",
    "Initialize $\\pi_0$\n",
    "\n",
    "For $n=0, 1, 2, \\dots$\n",
    "- Compute the state-value function $V^{\\pi_{n}}$\n",
    "- Compute new policy $\\pi_{n+1}(s) = \\operatorname*{argmax}_a V^{\\pi_{n}}(s,a)$\n",
    "---\n",
    "\n",
    "### Policy Evaluation\n",
    "\n",
    "Here, we implement a function called `policy_eval` that computes the state-value function $V^{\\pi}$ for an arbitrary policy $\\pi$.\n",
    "Recall that $V^{\\pi}$ satisfies the following linear equation:\n",
    "$$V^{\\pi}(s) = \\sum_{s'} P(s,\\pi(s),s')[ R(s,\\pi(s),s') + \\gamma V^{\\pi}(s')]$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "policy_eval"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Evaluate a policy given an environment and a full description of the environment's dynamics.\n",
    "    \n",
    "    Args:\n",
    "        π: [S] shaped vector representing the policy.\n",
    "        mdp: mdp.P represents the transition probabilities of the environment.\n",
    "            mdp.P[s][a] is a list of transition tuples (prob, next_state, reward).\n",
    "            mpd.nS is a number of states in the environment. \n",
    "            mdp.nA is a number of actions in the environment.\n",
    "        γ: discount factor.\n",
    "        θ: We stop evaluation once our value function change is less than theta for all states.\n",
    "    \n",
    "    Returns:\n",
    "        Vector of length mdp.nS representing the value function.\n",
    "\"\"\"\n",
    "function policy_eval(π, mdp, γ=0.95, θ=1e-4)\n",
    "    # Start with a random (all 0) value function\n",
    "    V = zeros(mdp.nS)\n",
    "    while true\n",
    "        Δ = 0\n",
    "        # For each state, perform a \"full backup\"\n",
    "        for s=1:mdp.nS\n",
    "            v = 0\n",
    "            # Look at the possible next actions\n",
    "            for a in π[s]\n",
    "                action_prob = 1.0#Deterministic policy\n",
    "                # For each action, look at the possible next states...\n",
    "                for  (prob, next_state, reward) in mdp.P[s][a]\n",
    "                    # Calculate the expected value\n",
    "                    v += action_prob * prob * (reward + γ * V[next_state])\n",
    "                end\n",
    "            end\n",
    "            # How much our value function changed (across any states)\n",
    "            Δ = max(Δ, abs(v - V[s]))\n",
    "            V[s] = v\n",
    "        end\n",
    "        # Stop evaluating once our value function change is below a threshold\n",
    "        if Δ < θ\n",
    "            break\n",
    "        end\n",
    "    end\n",
    "    return V\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "γ = 0.95\n",
    "θ = 1e-5\n",
    "random_policy = rand(1:mdp.nA, mdp.nS)\n",
    "V = policy_eval(random_policy, mdp, γ, θ);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Policy (Random) (1=left, 2=down, 3=right, 4=up)\n",
      "(reshape(random_policy, 4, 4))' = [4 2 2 4; 1 2 2 3; 1 4 1 2; 1 2 2 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Int64,Array{Int64,2}}:\n",
       " 4  2  2  4\n",
       " 1  2  2  3\n",
       " 1  4  1  2\n",
       " 1  2  2  4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Policy (Random) (1=left, 2=down, 3=right, 4=up)\")\n",
    "@show reshape(random_policy, 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Value Function\n",
      "(reshape(V, 4, 4))' = [0.00225769333872104 0.0034585980670282105 0.034150502683410494 0.022324845045985534; 0.0010514024312110366 0.0 0.041714060627618677 0.0; 0.000412838503787406 0.005253477236312138 0.05488811652885962 0.0; 0.0 0.1955245600514026 0.4940359377619923 0.0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Float64,Array{Float64,2}}:\n",
       " 0.00225769   0.0034586   0.0341505  0.0223248\n",
       " 0.0010514    0.0         0.0417141  0.0\n",
       " 0.000412839  0.00525348  0.0548881  0.0\n",
       " 0.0          0.195525    0.494036   0.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Value Function\")\n",
    "@show reshape(V, 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "policy_iteration"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Policy Iteration Algorithm. Iteratively evaluates and improves a policy.\n",
    "    \n",
    "    Args:\n",
    "        mdp: A markov decision process.\n",
    "        γ: discount factor.\n",
    "        nIt: number of iteration\n",
    "        \n",
    "    Returns: (value_functions, policies)\n",
    "        \n",
    "\"\"\"\n",
    "function policy_iteration(mdp, γ, nIt)\n",
    "    \"\"\"\n",
    "        Helper function to calculate the value for all action in a given state.\n",
    "        \n",
    "        Args:\n",
    "            state: The state to consider (int)\n",
    "            V: The value to use as an estimator, Vector of length mdp.nS\n",
    "        \n",
    "        Returns:\n",
    "            A vector of length mdp.nA containing the expected value of each action.\n",
    "    \"\"\"\n",
    "    function one_step_lookahead(state, V)\n",
    "        A = zeros(mdp.nA)\n",
    "        for a=1:mdp.nA\n",
    "            for (prob, next_state, reward) in mdp.P[state][a]\n",
    "                A[a] += prob * (reward + γ * V[next_state])\n",
    "            end\n",
    "        end\n",
    "        return A\n",
    "    end\n",
    "    Vs = []\n",
    "    πs = []\n",
    "    π_prev = rand(1:mdp.nA, mdp.nS)#start with a randomly initialized policy\n",
    "    push!(πs, π_prev)\n",
    "    println(\"Iteration | # chg actions | V[1]\")\n",
    "    println(\"----------+---------------+---------\")\n",
    "    \n",
    "    for it=1:nIt\n",
    "        π_prev = πs[end]\n",
    "        Vπ = policy_eval(π_prev, mdp, γ)\n",
    "        π = zeros(Int, mdp.nS)\n",
    "        for s=1:mdp.nS\n",
    "            # One step lookahead to find the best action for this state\n",
    "            A = one_step_lookahead(s, Vπ)\n",
    "            #there might me more than one action with max value\n",
    "            #chose the first one\n",
    "            best_action = findmax(A)[2]\n",
    "            # Always take the best action\n",
    "            π[s] = best_action\n",
    "        end\n",
    "        nChgActions= sum((π .!= π_prev))\n",
    "        println(@sprintf(\"%4i      | %6i        | %6.5f\", it, nChgActions, Vπ[1]))\n",
    "        push!(Vs, Vπ)\n",
    "        push!(πs, π)\n",
    "    end\n",
    "    return Vs, πs\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration | # chg actions | V[1]\n",
      "----------+---------------+---------\n",
      "   1      |     12        | 0.00000\n",
      "   2      |      2        | 0.31453\n",
      "   3      |      0        | 0.53115\n",
      "   4      |      0        | 0.53115\n",
      "   5      |      0        | 0.53115\n",
      "   6      |      0        | 0.53115\n",
      "   7      |      0        | 0.53115\n",
      "   8      |      0        | 0.53115\n",
      "   9      |      0        | 0.53115\n",
      "  10      |      0        | 0.53115\n",
      "  11      |      0        | 0.53115\n",
      "  12      |      0        | 0.53115\n",
      "  13      |      0        | 0.53115\n",
      "  14      |      0        | 0.53115\n",
      "  15      |      0        | 0.53115\n",
      "  16      |      0        | 0.53115\n",
      "  17      |      0        | 0.53115\n",
      "  18      |      0        | 0.53115\n",
      "  19      |      0        | 0.53115\n",
      "  20      |      0        | 0.53115\n"
     ]
    }
   ],
   "source": [
    "γ = 0.95\n",
    "Vs_PI, πs_PI = policy_iteration(mdp, γ, 20);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Policy (1=left, 2=down, 3=right, 4=up)\n",
      "(reshape(πs_PI[end], 4, 4))' = [2 3 2 1; 2 1 2 1; 3 2 2 1; 1 3 3 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Int64,Array{Int64,2}}:\n",
       " 2  3  2  1\n",
       " 2  1  2  1\n",
       " 3  2  2  1\n",
       " 1  3  3  1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Policy (1=left, 2=down, 3=right, 4=up)\")\n",
    "@show reshape(πs_PI[end], 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped Grid Value Function\n",
      "(reshape(Vs_PI[end], 4, 4))' = [0.531153543142387 0.4706328309466523 0.5604304103539807 0.4706372308089573; 0.5736920286267878 0.0 0.6197506771798792 0.0; 0.6831533972391979 0.827175715672551 0.815461591696045 0.0; 0.0 0.9010625052319627 0.9695788385495183 0.0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×4 LinearAlgebra.Adjoint{Float64,Array{Float64,2}}:\n",
       " 0.531154  0.470633  0.56043   0.470637\n",
       " 0.573692  0.0       0.619751  0.0\n",
       " 0.683153  0.827176  0.815462  0.0\n",
       " 0.0       0.901063  0.969579  0.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"Reshaped Grid Value Function\")\n",
    "@show reshape(Vs_PI[end], 4, 4)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Plots; default(fmt=:png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels = reshape(map(x->\"V\"*string(x), 1:mdp.nS), 1, mdp.nS)\n",
    "plot(hcat(Vs_PI...)',label=labels, title=\"State Values for Policy Iteration\")\n",
    "xlabel!(\"Number of iterations\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can compare the convergence of value iteration and policy iteration on several states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plots = []\n",
    "pallettes = [:blues, :reds, :greens, :blues, :reds]\n",
    "states = [1,9,11,14,15]\n",
    "for i=1:length(states)\n",
    "    s = states[i]\n",
    "    push!(plots, plot(hcat(hcat(Vs_VI[2:end]...)'[:, s], hcat(Vs_PI...)'[:, s]),\n",
    "            labels=[\"VI State $s\" \"PI State $s\"],\n",
    "            ylabel=\"V$s\", color_palette=pallettes[i], lw=4)\n",
    "    )\n",
    "end\n",
    "plot(plots...,layout=(5,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.5.0",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
